home *** CD-ROM | disk | FTP | other *** search
/ The CICA Windows Explosion! / The CICA Windows Explosion! - Disc 2.iso / winsock / ircii2-6.zip / SRC\IRCII-2.6\SOURCE\ALIAS.C < prev    next >
Text File  |  1994-12-31  |  61KB  |  2,897 lines
  1. /*
  2.  * alias.c Handles command aliases for irc.c 
  3.  *
  4.  * Written By Michael Sandrof
  5.  *
  6.  * Copyright(c) 1990 
  7.  *
  8.  * See the COPYRIGHT file, or do a HELP IRCII COPYRIGHT 
  9.  */
  10.  
  11. #ifndef lint
  12. static    char    rcsid[] = "@(#)$Id: alias.c,v 1.28 1994/10/15 23:11:03 mrg Stab $";
  13. #endif
  14.  
  15. #include "irc.h"
  16.  
  17. #include "alias.h"
  18. #include "status.h"
  19. #include "edit.h"
  20. #include "history.h"
  21. #include "vars.h"
  22. #include "ircaux.h"
  23. #include "server.h"
  24. #include "screen.h"
  25. #include "window.h"
  26. #include "input.h"
  27. #include "names.h"
  28. #include "server.h"
  29. #include "output.h"
  30. #include "names.h"
  31.  
  32. extern    char    *dcc_raw_listen();
  33. extern    char    *dcc_raw_connect();
  34.  
  35. extern    void    strmcat();
  36. extern    void    strmcat_ue();
  37.  
  38. extern    char    *FromUserHost;
  39.  
  40. extern    int    parse_number __P((char **));
  41. static    char    *next_unit __P((char *, char *, int *, int));
  42. static    long    randm();
  43.  
  44. static    char    *alias_detected();
  45. static    char    *alias_sent_nick();
  46. static    char    *alias_recv_nick();
  47. static    char    *alias_msg_body();
  48. static    char    *alias_joined_nick();
  49. static    char    *alias_public_nick();
  50. static    char    *alias_dollar();
  51. static    char    *alias_channel();
  52. static    char    *alias_server();
  53. static    char    *alias_query_nick();
  54. static    char    *alias_target();
  55. static    char    *alias_nick();
  56. static    char    *alias_invite();
  57. static    char    *alias_cmdchar();
  58. static    char    *alias_line();
  59. static    char    *alias_away();
  60. static    char    *alias_oper();
  61. static    char    *alias_chanop();
  62. static    char    *alias_modes();
  63. static    char    *alias_buffer();
  64. static    char    *alias_time();
  65. static    char    *alias_version();
  66. static    char    *alias_currdir();
  67. static    char    *alias_current_numeric();
  68. static    char    *alias_server_version();
  69.  
  70. typedef struct
  71. {
  72.     char    name;
  73.     char    *(*func)();
  74. }    BuiltIns;
  75.  
  76. static    FAR BuiltIns built_in[] =
  77. {
  78.     { '.',        alias_sent_nick },
  79.     { ',',        alias_recv_nick },
  80.     { ':',        alias_joined_nick },
  81.     { ';',        alias_public_nick },
  82.     { '$',        alias_dollar },
  83.     { 'A',        alias_away },
  84.     { 'B',        alias_msg_body },
  85.     { 'C',        alias_channel },
  86.     { 'D',        alias_detected },
  87. /*
  88.     { 'E' },
  89.     { 'F' },
  90.     { 'G' },
  91. */
  92.     { 'H',         alias_current_numeric },
  93.     { 'I',        alias_invite },
  94. /*
  95.     { 'J' },
  96. */
  97.     { 'K',        alias_cmdchar },
  98.     { 'L',        alias_line },
  99.     { 'M',        alias_modes },
  100.     { 'N',        alias_nick },
  101.     { 'O',        alias_oper },
  102.     { 'P',        alias_chanop },
  103.     { 'Q',        alias_query_nick },
  104.     { 'R',        alias_server_version },
  105.     { 'S',        alias_server },
  106.     { 'T',        alias_target },
  107.     { 'U',        alias_buffer },
  108.     { 'V',        alias_version },
  109.     { 'W',        alias_currdir },
  110. /*
  111.     { 'X' },
  112.     { 'Y' },
  113. */
  114.     { 'Z',        alias_time },
  115.     { (char) 0,     NULL }
  116. };
  117.  
  118.     char    FAR command_line[BIG_BUFFER_SIZE+1] = "";
  119.  
  120.     char    *function_left __P((char *));
  121.     char    *function_right __P((char *));
  122.     char    *function_mid __P((char *));
  123.     char    *function_rand __P((char *));
  124.     char    *function_srand __P((char *));
  125.     char    *function_time __P((char *));
  126.     char    *function_stime __P((char *));
  127.     char    *function_index __P((char *));
  128.     char    *function_rindex __P((char *));
  129.     char    *function_match __P((char *));
  130.     char    *function_rmatch __P((char *));
  131.     char    *function_userhost __P((char *));
  132.     char    *function_strip __P((char *));
  133.     char    *function_encode __P((unsigned char *));
  134.     char    *function_decode __P((unsigned char *));
  135.     char    *function_ischannel __P((char *));
  136.     char    *function_ischanop __P((char *));
  137.     char    *function_word __P((char *));
  138.     char    *function_winnum __P((char *));
  139.     char    *function_winnam __P((char *));
  140.     char    *function_connect __P((char *));
  141.     char    *function_listen __P((char *));
  142.     char    *function_tdiff __P((char *));
  143.     char    *function_toupper __P((char *));
  144.     char    *function_tolower __P((char *));
  145.     char    *function_channels __P((char *));
  146.     char    *function_servers __P((char *));
  147.     char    *function_curpos __P((char *));
  148.     char    *function_onchannel __P((char *));
  149.     char    *function_pid __P((char *));
  150.     char    *function_ppid __P((char *));
  151.     char    *function_chanusers __P((char *));
  152.     char    *function_strftime __P((char *));
  153.  
  154. typedef struct
  155. {
  156.     char    *name;
  157.     char    *(*func)();
  158. }    BuiltInFunctions;
  159.  
  160. static BuiltInFunctions    FAR built_in_functions[] =
  161. {
  162.     { "LEFT",        function_left },
  163.     { "RIGHT",        function_right },
  164.     { "MID",        function_mid },
  165.     { "RAND",        function_rand },
  166.     { "SRAND",        function_srand },
  167.     { "TIME",        function_time },
  168.     { "TDIFF",        function_tdiff },
  169.     { "STIME",        function_stime },
  170.     { "INDEX",        function_index },
  171.     { "RINDEX",        function_rindex },
  172.     { "MATCH",        function_match },
  173.     { "RMATCH",        function_rmatch },
  174.     { "USERHOST",        function_userhost },
  175.     { "STRIP",        function_strip },
  176.     { "ENCODE",        function_encode },
  177.     { "DECODE",        function_decode },
  178.     { "ISCHANNEL",        function_ischannel },
  179.     { "ISCHANOP",        function_ischanop },
  180.     { "WORD",        function_word },
  181.     { "WINNUM",        function_winnum },
  182.     { "WINNAM",        function_winnam },
  183.     { "CONNECT",        function_connect },
  184.     { "LISTEN",        function_listen },
  185.     { "TOUPPER",        function_toupper },
  186.     { "TOLOWER",        function_tolower },
  187.     { "MYCHANNELS",        function_channels },
  188.     { "MYSERVERS",        function_servers },
  189.     { "CURPOS",        function_curpos },
  190.     { "ONCHANNEL",        function_onchannel },
  191.     { "PID",        function_pid },
  192.     { "PPID",        function_ppid },
  193.     { "CHANUSERS",        function_chanusers },
  194.     { "STRFTIME",        function_strftime },
  195.     { (char *) 0,        NULL }
  196. };
  197.  
  198. /* alias_illegals: characters that are illegal in alias names */
  199.     char    alias_illegals[] = " #+-*/\\()={}[]<>!@$%^~`,?;:|'\"";
  200.  
  201. static    Alias    *alias_list[] =
  202. {
  203.     (Alias *) 0,
  204.     (Alias *) 0
  205. };
  206.  
  207. /* alias_string: the thing that gets replaced by the $"..." construct */
  208. static    char    *alias_string = (char *) 0;
  209.  
  210. static    int    eval_args;
  211.  
  212. /* function_stack and function_stkptr - hold the return values from functions */
  213. static    char    * FAR function_stack[128] =
  214. { 
  215.     (char *) 0
  216. };
  217. static    int    function_stkptr = 0;
  218.  
  219. extern    char    *MatchingBracket();
  220.  
  221. /*
  222.  * find_alias: looks up name in in alias list.  Returns the Alias    entry if
  223.  * found, or null if not found.   If unlink is set, the found entry is
  224.  * removed from the list as well.  If match is null, only perfect matches
  225.  * will return anything.  Otherwise, the number of matches will be returned. 
  226.  */
  227. static    Alias    *
  228. find_alias(list, name, unlink, match)
  229.     Alias    **list;
  230.     char    *name;
  231.     int    unlink;
  232.     int    *match;
  233. {
  234.     Alias    *tmp,
  235.         *last = (Alias *) 0;
  236.     int    cmp,
  237.         len;
  238.     int    (*cmp_func)();
  239.  
  240.     if (match)
  241.     {
  242.         *match = 0;
  243.         cmp_func = my_strnicmp;
  244.     }
  245.     else
  246.         cmp_func = my_stricmp;
  247.     if (name)
  248.     {
  249.         len = strlen(name);
  250.         for (tmp = *list; tmp; tmp = tmp->next)
  251.         {
  252.             if ((cmp = cmp_func(name, tmp->name, len)) == 0)
  253.             {
  254.                 if (unlink)
  255.                 {
  256.                     if (last)
  257.                         last->next = tmp->next;
  258.                     else
  259.                         *list = tmp->next;
  260.                 }
  261.                 if (match)
  262.                 {
  263.                     (*match)++;
  264.                     if (strlen(tmp->name) == len)
  265.                     {
  266.                         *match = 0;
  267.                         return (tmp);
  268.                     }
  269.                 }
  270.                 else
  271.                     return (tmp);
  272.             }
  273.             else if (cmp < 0)
  274.                 break;
  275.             last = tmp;
  276.         }
  277.     }
  278.     if (match && (*match == 1))
  279.         return (last);
  280.     else
  281.         return ((Alias *) 0);
  282. }
  283.  
  284. /*
  285.  * insert_alias: adds the given alias to the alias list.  The alias list is
  286.  * alphabetized by name 
  287.  */
  288. static    void    
  289. insert_alias(list, alias)
  290.     Alias    **list;
  291.     Alias    *alias;
  292. {
  293.     Alias    *tmp,
  294.         *last,
  295.         *foo;
  296.  
  297.     last = (Alias *) 0;
  298.     for (tmp = *list; tmp; tmp = tmp->next)
  299.     {
  300.         if (strcmp(alias->name, tmp->name) < 0)
  301.             break;
  302.         last = tmp;
  303.     }
  304.     if (last)
  305.     {
  306.         foo = last->next;
  307.         last->next = alias;
  308.         alias->next = foo;
  309.     }
  310.     else
  311.     {
  312.         alias->next = *list;
  313.         *list = alias;
  314.     }
  315. }
  316.  
  317. /*
  318.  * add_alias: given the alias name and "stuff" that makes up the alias,
  319.  * add_alias() first checks to see if the alias name is already in use... if
  320.  * so, the old alias is replaced with the new one.  If the alias is not
  321.  * already in use, it is added. 
  322.  */
  323. void    
  324. add_alias(type, name, stuff)
  325.     int    type;
  326.     char    *name,
  327.         *stuff;
  328. {
  329.     Alias    *tmp;
  330.     char    *ptr;
  331.  
  332.     upper(name);
  333.     if (type == COMMAND_ALIAS)
  334.         say("Alias    %s added", name);
  335.     else
  336.     {
  337.         if (!strcmp(name, "FUNCTION_RETURN"))
  338.         {
  339.             if (function_stack[function_stkptr])
  340.                 new_free(&function_stack[function_stkptr]);
  341.             malloc_strcpy(&function_stack[function_stkptr], stuff);
  342.             return;
  343.         }
  344.         if ((ptr = sindex(name, alias_illegals)) != NULL)
  345.         {
  346.             yell("Assign names may not contain '%c'", *ptr);
  347.             return;
  348.         }
  349.         say("Assign %s added", name);
  350.     }
  351.     if ((tmp = find_alias(&(alias_list[type]), name, 1, (int *) 0)) ==
  352.             (Alias *) 0)
  353.     {
  354.         tmp = (Alias *) new_malloc(sizeof(Alias));
  355.         if (tmp == (Alias *) 0)
  356.         {
  357.             yell("Couldn't allocate memory for new alias!");
  358.             return;
  359.         }
  360.         tmp->name = (char *) 0;
  361.         tmp->stuff = (char *) 0;
  362.     }
  363.     malloc_strcpy(&(tmp->name), name);
  364.     malloc_strcpy(&(tmp->stuff), stuff);
  365.     tmp->mark = 0;
  366.     tmp->global = loading_global;
  367.     insert_alias(&(alias_list[type]), tmp);
  368. }
  369.  
  370. /* alias_arg: a special version of next_arg for aliases */
  371. static    char    *
  372. alias_arg(str, pos)
  373.     char    **str;
  374.     u_int    *pos;
  375. {
  376.     char    *ptr;
  377.  
  378.     if (!*str)
  379.         return (char *) 0;
  380.     *pos = 0;
  381.     ptr = *str;
  382.     while (' ' == *ptr)
  383.     {
  384.         ptr++;
  385.         (*pos)++;
  386.     }
  387.     if (*ptr == '\0')
  388.     {
  389.         *str = empty_string;
  390.         return ((char *) 0);
  391.     }
  392.     if ((*str = sindex(ptr, " ")) != NULL)
  393.         *((*str)++) = '\0';
  394.     else
  395.         *str = empty_string;
  396.     return (ptr);
  397. }
  398.  
  399. /* word_count: returns the number of words in the given string */
  400. extern    int    
  401. word_count(str)
  402.     char    *str;
  403. {
  404.     int    cnt = 0;
  405.     char    *ptr;
  406.  
  407.     while (1)
  408.     {
  409.         if ((ptr = sindex(str, "^ ")) != NULL)
  410.         {
  411.             cnt++;
  412.             if ((str = sindex(ptr, " ")) == (char *) 0)
  413.                 return (cnt);
  414.         }
  415.         else
  416.             return (cnt);
  417.     }
  418. }
  419.  
  420. static    char    *
  421. built_in_alias(c)
  422.     char    c;
  423. {
  424.     BuiltIns    *tmp;
  425.     char    *ret = (char *) 0;
  426.  
  427.     for(tmp = built_in;tmp->name;tmp++)
  428.         if (c == tmp->name)
  429.         {
  430.             malloc_strcpy(&ret, tmp->func());
  431.             break;
  432.         }
  433.     return(ret);
  434. }
  435.  
  436. /*
  437.  * find_inline: This simply looks up the given str.  It first checks to see
  438.  * if its a user variable and returns it if so.  If not, it checks to see if
  439.  * it's an IRC variable and returns it if so.  If not, it checks to see if
  440.  * its and environment variable and returns it if so.  If not, it returns
  441.  * null.  It mallocs the returned string 
  442.  */
  443. static    char    *
  444. find_inline(str)
  445.     char    *str;
  446. {
  447.     Alias    *alias;
  448.     char    *ret = NULL;
  449.     char    *tmp;
  450.  
  451.     if ((alias = find_alias(&(alias_list[VAR_ALIAS]), str, 0, (int *) NULL))
  452.             != NULL)
  453.     {
  454.         malloc_strcpy(&ret, alias->stuff);
  455.         return (ret);
  456.     }
  457.     if ((strlen(str) == 1) && (ret = built_in_alias(*str)))
  458.         return(ret);
  459.     if ((ret = make_string_var(str)) != NULL)
  460.         return (ret);
  461. #ifdef DAEMON_UID
  462.     if (getuid() == DAEMON_UID)
  463.     malloc_strcpy(&ret, (getuid() != DAEMON_UID) && (tmp = getenv(str)) ?
  464.                 tmp : empty_string);
  465. #else
  466.     malloc_strcpy(&ret, (tmp = getenv(str)) ? tmp : empty_string);
  467. #endif /* DAEMON_UID */
  468.     return (ret);
  469. }
  470.  
  471. static    char    *
  472. call_function(name, f_args, args, args_flag)
  473.     char    *name,
  474.         *f_args,
  475.         *args;
  476.     int    *args_flag;
  477. {
  478.     char    *tmp;
  479.     char    *result = (char *) 0;
  480.     char    *sub_buffer = (char *) 0;
  481.     int    builtnum;
  482.     char    *debug_copy = (char *) 0;
  483.  
  484.     tmp = expand_alias((char *) 0, f_args, args, args_flag, NULL);
  485.     if (get_int_var(DEBUG_VAR) & DEBUG_FUNCTIONS)
  486.         malloc_strcpy(&debug_copy, tmp);
  487.     for (builtnum = 0; built_in_functions[builtnum].name != NULL &&
  488.             my_stricmp(built_in_functions[builtnum].name, name);
  489.             builtnum++)
  490.         ;
  491.     if (built_in_functions[builtnum].name)
  492.         result = built_in_functions[builtnum].func(tmp);
  493.     else
  494.     {
  495.         sub_buffer = new_malloc(strlen(name)+strlen(tmp)+2);
  496.         strcpy(sub_buffer, name);
  497.         strcat(sub_buffer, " ");
  498.         strcat(sub_buffer, tmp);
  499.         function_stack[++function_stkptr] = (char *) 0;
  500.         parse_command(sub_buffer, 0, empty_string);
  501.         new_free(&sub_buffer);
  502.         eval_args=1;
  503.         result = function_stack[function_stkptr];
  504.         function_stack[function_stkptr] = (char *) 0;
  505.         if (!result)
  506.             malloc_strcpy(&result, empty_string);
  507.         function_stkptr--;
  508.     }
  509.     if (debug_copy)
  510.     {
  511.         yell("Function %s(%s) returned %s",
  512.             name, debug_copy, result);
  513.         new_free(&debug_copy);
  514.     }
  515.     new_free(&tmp);
  516.     return result;
  517. }
  518.  
  519.  
  520. /* Given a pointer to an operator, find the last operator in the string */
  521. char    *
  522. lastop(ptr)
  523.     char    *ptr;
  524. {
  525.     while (ptr[1] && index("!=<>&^|#+/-*", ptr[1]))
  526.         ptr++;
  527.     return ptr;
  528. }
  529.  
  530. #define    NU_EXPR    0
  531. #define    NU_CONJ NU_EXPR
  532. #define    NU_ASSN    1
  533. #define    NU_COMP 2
  534. #define    NU_ADD  3
  535. #define    NU_MULT 4
  536. #define    NU_UNIT 5
  537. #define    NU_TERT 6
  538. #define    NU_BITW 8
  539.  
  540. static    char    *
  541. next_unit(str, args, arg_flag, stage)
  542.     char    *str,
  543.         *args;
  544.     int    *arg_flag,
  545.         stage;
  546. {
  547.     char    *ptr,
  548.         *ptr2,
  549.         *right;
  550.     int    got_sloshed = 0;
  551.     char    *lastc;
  552.     char    tmp[40];
  553.     char    *result1 = (char *) 0,
  554.         *result2 = (char *) 0;
  555.     long    value1 = 0,
  556.         value2,
  557.         value3;
  558.     char    op;
  559.     int    display;
  560.     char    *ArrayIndex,
  561.         *EndIndex;
  562.  
  563.     while (isspace(*str))
  564.         ++str;
  565.     if (!*str)
  566.     {
  567.         malloc_strcpy(&result1, empty_string);
  568.         return result1;
  569.     }
  570.     lastc = str+strlen(str)-1;
  571.     while (isspace(*lastc))
  572.         *lastc-- = '\0';
  573.     if (stage == NU_UNIT && *lastc == ')' && *str == '(')
  574.     {
  575.         str++, *lastc-- = '\0';
  576.         return next_unit(str, args, arg_flag, NU_EXPR);
  577.     }
  578.     if (!*str)
  579.     {
  580.         malloc_strcpy(&result1, empty_string);
  581.         return result1;
  582.     }
  583.     for (ptr = str; *ptr; ptr++)
  584.     {
  585.         if (got_sloshed) /* Help! I'm drunk! */
  586.         {
  587.             got_sloshed = 0;
  588.             continue;
  589.         }
  590.         switch(*ptr)
  591.         {
  592.         case '\\':
  593.             got_sloshed = 1;
  594.             continue;
  595.         case '(':
  596.             if (stage != NU_UNIT || ptr == str)
  597.             {
  598.                 if (!(ptr2 = MatchingBracket(ptr+1, '(', ')')))
  599.                     ptr = ptr+strlen(ptr)-1;
  600.                 else
  601.                     ptr = ptr2;
  602.                 break;
  603.             }
  604.             *ptr++ = '\0';
  605.             right = ptr;
  606.             ptr = MatchingBracket(right, LEFT_PAREN, RIGHT_PAREN);
  607.             if (ptr)
  608.                 *ptr++ = '\0';
  609.             result1 = call_function(str, right, args, arg_flag);
  610.             if (ptr && *ptr)
  611.             {
  612.                 malloc_strcat(&result1, ptr);
  613.                 result2 = next_unit(result1, args, arg_flag,
  614.                         stage);
  615.                 new_free(&result1);
  616.                 result1 = result2;
  617.             }
  618.             return result1;
  619.         case '[':
  620.             if (stage != NU_UNIT)
  621.             {
  622.                 if (!(ptr2 = MatchingBracket(ptr+1, '[', ']')))
  623.                     ptr = ptr+strlen(ptr)-1;
  624.                 else
  625.                     ptr = ptr2;
  626.                 break;
  627.             }
  628.             *ptr++ = '\0';
  629.             right = ptr;
  630.             ptr = MatchingBracket(right, LEFT_BRACKET, RIGHT_BRACKET);
  631.             if (ptr)
  632.                 *ptr++ = '\0';
  633.             result1 = expand_alias((char *) 0, right, args, arg_flag, NULL);
  634.             if (*str)
  635.             {
  636.                 result2 = new_malloc(strlen(str)+
  637.                         (result1?strlen(result1):0)+
  638.                         (ptr?strlen(ptr):0) + 2);
  639.                 strcpy(result2, str);
  640.                 strcat(result2, ".");
  641.                 strcat(result2, result1);
  642.                 new_free(&result1);
  643.                 if (ptr && *ptr)
  644.                 {
  645.                     strcat(result2, ptr);
  646.                     result1 = next_unit(result2, args,
  647.                         arg_flag, stage);
  648.                 }
  649.                 else
  650.                 {
  651.                     result1 = find_inline(result2);
  652.                     if (!result1)
  653.                         malloc_strcpy(&result1,
  654.                             empty_string);
  655.                 }
  656.                 new_free(&result2);
  657.             }
  658.             else if (ptr && *ptr)
  659.             {
  660.                 malloc_strcat(&result1, ptr);
  661.                 result2 = next_unit(result1, args, arg_flag,
  662.                     stage);
  663.                 new_free(&result1);
  664.                 result1 = result2;
  665.             }
  666.             return result1;
  667.         case '-':
  668.         case '+':
  669.                         if (*(ptr+1) == *(ptr))  /* index operator */
  670.                         {
  671.                                 char *tptr;
  672.  
  673.                                 *ptr++ = '\0';
  674.                 if (ptr == str + 1)    /* Its a prefix */
  675.                                 {
  676.                                         tptr = str + 2;
  677.                                 }
  678.                 else            /* Its a postfix */
  679.                                 {
  680.                                         tptr = str;
  681.                                 }
  682.                     result1 = find_inline(tptr);
  683.                                 if (!result1) 
  684.                                         malloc_strcpy(&result1,"0");
  685.  
  686.                                 {           /* This isnt supposed to be
  687.                                                 attached to the if, so
  688.                                                 dont "fix" it. */
  689.                                         int r;
  690.                                         r = atoi(result1);
  691.                                         if (*ptr == '+')
  692.                                                 r++;
  693.                                         else    r--;
  694.                                         sprintf(tmp,"%ld",r);
  695.                                         display = window_display;
  696.                                         window_display = 0;
  697.                                         add_alias(VAR_ALIAS,tptr,tmp);
  698.                                         window_display = display;
  699.                                 }
  700.         /* A kludge?  Cheating?  Maybe.... */
  701.                 if (ptr == str + 1) 
  702.                 {
  703.                                     *(ptr-1) = ' ';
  704.                     *ptr = ' ';
  705.                 } else            
  706.                 {
  707.                                         if (*ptr == '+')
  708.                             *(ptr-1) = '-';
  709.                                         else
  710.                                                 *(ptr-1) = '+';
  711.                     *ptr = '1';
  712.                 }
  713.                                 ptr = str; 
  714.                                 new_free(&result1);
  715.                                 break;
  716.                         }
  717.             if (ptr == str) /* It's unary..... do nothing */
  718.                 break;
  719.             if (stage != NU_ADD)
  720.             {
  721.                 ptr = lastop(ptr);
  722.                 break;
  723.             }
  724.             op = *ptr;
  725.             *ptr++ = '\0';
  726.             result1 = next_unit(str, args, arg_flag, stage);
  727.             result2 = next_unit(ptr, args, arg_flag, stage);
  728.             value1 = atol(result1);
  729.             value2 = atol(result2);
  730.             new_free(&result1);
  731.             new_free(&result2);
  732.             if (op == '-')
  733.                 value3 = value1 - value2;
  734.             else
  735.                 value3 = value1 + value2;
  736.             sprintf(tmp, "%ld", value3);
  737.             malloc_strcpy(&result1, tmp);
  738.             return result1;
  739.         case '/':
  740.         case '*':
  741.           case '%':
  742.             if (stage != NU_MULT)
  743.             {
  744.                 ptr = lastop(ptr);
  745.                 break;
  746.             }
  747.             op = *ptr;
  748.             *ptr++ = '\0';
  749.             result1 = next_unit(str, args, arg_flag, stage);
  750.             result2 = next_unit(ptr, args, arg_flag, stage);
  751.             value1 = atol(result1);
  752.             value2 = atol(result2);
  753.             new_free(&result1);
  754.             new_free(&result2);
  755.             if (op == '/')
  756.             {
  757.                 if (value2)
  758.                     value3 = value1 / value2;
  759.                 else
  760.                 {
  761.                     value3 = 0;
  762.                     say("Division by zero");
  763.                 }
  764.             }
  765.             else
  766.                         if (op == '*')
  767.                 value3 = value1 * value2;
  768.                         else
  769.                         {
  770.                                 if (value2)
  771.                                     value3 = value1 % value2;
  772.                                 else
  773.                                 {
  774.                                         value3 = 0;
  775.                                         say("Mod by zero");
  776.                                 }
  777.                         }
  778.             sprintf(tmp, "%ld", value3);
  779.             malloc_strcpy(&result1, tmp);
  780.             return result1;
  781.         case '#':
  782.             if (stage != NU_ADD || ptr[1] != '#')
  783.             {
  784.                 ptr = lastop(ptr);
  785.                 break;
  786.             }
  787.             *ptr = '\0';
  788.             ptr += 2;
  789.             result1 = next_unit(str, args, arg_flag, stage);
  790.             result2 = next_unit(ptr, args, arg_flag, stage);
  791.             malloc_strcat(&result1, result2);
  792.             new_free(&result2);
  793.             return result1;
  794.     /* Reworked - Jeremy Nelson, Feb 1994
  795.      * & or && should both be supported, each with different
  796.      * stages, same with || and ^^.  Also, they should be
  797.      * short-circuit as well.
  798.      */
  799.         case '&':
  800.             if (ptr[0] == ptr[1])
  801.             {
  802.                 if (stage != NU_CONJ)
  803.                 {
  804.                     ptr = lastop(ptr);
  805.                     break;
  806.                 }
  807.                 *ptr = '\0';
  808.                 ptr += 2;
  809.                 result1 = next_unit(str, args, arg_flag, stage);
  810.                 value1 = atol(result1);
  811.                 if (value1)
  812.                 {
  813.                     result2 = next_unit(ptr, args, arg_flag, stage);
  814.                     value2 = atol(result2);
  815.                     value3 = value1 && value2;
  816.                 }
  817.                 else
  818.                     value3 = 0;
  819.                 new_free(&result1);
  820.                 new_free(&result2);
  821.                                 tmp[0] = '0' + (value3?1:0);
  822.                                 tmp[1] = '\0';
  823.                 malloc_strcpy(&result1, tmp);
  824.                  return result1;
  825.             }
  826.             else
  827.             {
  828.                 if (stage != NU_BITW)
  829.                 {
  830.                     ptr = lastop(ptr);
  831.                     break;
  832.                 }
  833.                 *ptr = '\0';
  834.                 ptr += 1;
  835.                 result1 = next_unit(str, args, arg_flag, stage);
  836.                 result2 = next_unit(ptr, args, arg_flag, stage);
  837.                 value1 = atol(result1);
  838.                 value2 = atol(result2);
  839.                 new_free(&result1);
  840.                 new_free(&result2);
  841.                 value3 = value1 & value2;
  842.                                 sprintf(tmp, "%ld",value3);
  843.                 malloc_strcpy(&result1, tmp);
  844.                  return result1;
  845.             }
  846.         case '|':
  847.             if (ptr[0] == ptr[1])
  848.             {
  849.                 if (stage != NU_CONJ)
  850.                 {
  851.                     ptr = lastop(ptr);
  852.                     break;
  853.                 }
  854.                 *ptr = '\0';
  855.                 ptr += 2;
  856.                 result1 = next_unit(str, args, arg_flag, stage);
  857.                 value1 = atol(result1);
  858.                 if (!value1)
  859.                 {
  860.                     result2 = next_unit(ptr, args, arg_flag, stage);
  861.                     value2 = atol(result2);
  862.                     value3 = value1 || value2;
  863.                 }
  864.                 else    
  865.                     value3 = 1;
  866.                 new_free(&result1);
  867.                 new_free(&result2);
  868.                 tmp[0] = '0' + (value3 ? 1 : 0);
  869.                 tmp[1] = '\0';
  870.                 malloc_strcpy(&result1, tmp);
  871.                  return result1;
  872.             }
  873.             else
  874.             {
  875.                 if (stage != NU_BITW)
  876.                 {
  877.                     ptr = lastop(ptr);
  878.                     break;
  879.                 }
  880.                 *ptr = '\0';
  881.                 ptr += 1;
  882.                 result1 = next_unit(str, args, arg_flag, stage);
  883.                 result2 = next_unit(ptr, args, arg_flag, stage);
  884.                 value1 = atol(result1);
  885.                 value2 = atol(result2);
  886.                 new_free(&result1);
  887.                 new_free(&result2);
  888.                 value3 = value1 | value2;
  889.                                 sprintf(tmp, "%ld",value3);
  890.                 malloc_strcpy(&result1, tmp);
  891.                  return result1;
  892.             }
  893.         case '^':
  894.             if (ptr[0] == ptr[1])
  895.             {
  896.                 if (stage != NU_CONJ)
  897.                 {
  898.                     ptr = lastop(ptr);
  899.                     break;
  900.                 }
  901.                 *ptr = '\0';
  902.                 ptr += 2;
  903.                 result1 = next_unit(str, args, arg_flag, stage);
  904.                 result2 = next_unit(ptr, args, arg_flag, stage);
  905.                 value1 = atol(result1);
  906.                 value2 = atol(result2);
  907.                 value1 = value1?1:0;
  908.                 value2 = value2?1:0;
  909.                 value3 = value1 ^ value2;
  910.                 new_free(&result1);
  911.                 new_free(&result2);
  912.                 tmp[0] = '0' + (value3 ? 1 : 0);
  913.                 tmp[1] = '\0';
  914.                 malloc_strcpy(&result1, tmp);
  915.                  return result1;
  916.             }
  917.             else
  918.             {
  919.                 if (stage != NU_BITW)
  920.                 {
  921.                     ptr = lastop(ptr);
  922.                     break;
  923.                 }
  924.                 *ptr = '\0';
  925.                 ptr += 1;
  926.                 result1 = next_unit(str, args, arg_flag, stage);
  927.                 result2 = next_unit(ptr, args, arg_flag, stage);
  928.                 value1 = atol(result1);
  929.                 value2 = atol(result2);
  930.                 new_free(&result1);
  931.                 new_free(&result2);
  932.                 value3 = value1 ^ value2;
  933.                                 sprintf(tmp, "%ld",value3);
  934.                 malloc_strcpy(&result1, tmp);
  935.                  return result1;
  936.             }
  937.                 case '?':
  938.                         if (stage != NU_TERT)
  939.                         {
  940.                 ptr = lastop(ptr);
  941.                 break;
  942.             }
  943.             *ptr++ = '\0';
  944.             result1 = next_unit(str, args, arg_flag, stage);
  945.             ptr2 = index(ptr, ':');
  946.             *ptr2++ = '\0';
  947.                         right = result1;
  948.                         value1 = parse_number(&right);
  949.                         if ((value1 == -1) && (*right == (char) 0))
  950.                                 value1 = 0;
  951.                         if ( value1 == 0 )
  952.                                 while (isspace(*right))
  953.                                         *(right++) = '\0';
  954.                         if ( value1 || *right )
  955.                 result2 = next_unit(ptr, args, arg_flag, stage);
  956.             else
  957.                 result2 = next_unit(ptr2, args, arg_flag, stage);
  958.                         *(ptr2-1) = ':';
  959.             new_free(&result1);
  960.             return result2;
  961.         case '=':
  962.             if (ptr[1] != '=')
  963.             {
  964.                 if (stage != NU_ASSN)
  965.                 {
  966.                     ptr = lastop(ptr);
  967.                     break;
  968.                 }
  969.                 *ptr++ = '\0';
  970.                 result1 = expand_alias((char *) 0, str,
  971.                     args, arg_flag, NULL);
  972.                 result2 = next_unit(ptr, args, arg_flag, stage);
  973.                 display = window_display;
  974.                 window_display = 0;
  975.                 lastc = result1 + strlen(result1) - 1;
  976.                 while (lastc > result1 && *lastc == ' ')
  977.                     *lastc-- = '\0';
  978.                 for (ptr = result1; *ptr == ' '; ptr++);
  979.                 while ((ArrayIndex = (char *) index(ptr, '['))
  980.                         != NULL)
  981.                 {
  982.                     *ArrayIndex++='.';
  983.                     if ((EndIndex = MatchingBracket(ArrayIndex,
  984.                         LEFT_BRACKET, RIGHT_BRACKET)) != NULL)
  985.                     {
  986.                         *EndIndex++='\0';
  987.                         strcat(ptr, EndIndex);
  988.                     }
  989.                     else
  990.                         break;
  991.                 }
  992.                 if (*ptr)
  993.                     add_alias(VAR_ALIAS, ptr, result2);
  994.                 else
  995.                     yell("Invalid assignment expression");
  996.                 window_display = display;
  997.                 new_free(&result1);
  998.                 return result2;
  999.             }
  1000.             if (stage != NU_COMP)
  1001.             {
  1002.                 ptr = lastop(ptr);
  1003.                 break;
  1004.             }
  1005.             *ptr = '\0';
  1006.             ptr += 2;
  1007.             result1 = next_unit(str, args, arg_flag, stage);
  1008.             result2 = next_unit(ptr, args, arg_flag, stage);
  1009.             if (!my_stricmp(result1, result2))
  1010.                 malloc_strcpy(&result1, "1");
  1011.             else
  1012.                 malloc_strcpy(&result1, "0");
  1013.             new_free(&result2);
  1014.             return result1;
  1015.         case '>':
  1016.         case '<':
  1017.             if (stage != NU_COMP)
  1018.             {
  1019.                 ptr = lastop(ptr);
  1020.                 break;
  1021.             }
  1022.             op = *ptr;
  1023.             if (ptr[1] == '=')
  1024.                 value3 = 1, *ptr++ = '\0';
  1025.             else
  1026.                 value3 = 0;
  1027.             *ptr++ = '\0';
  1028.             result1 = next_unit(str, args, arg_flag, stage);
  1029.             result2 = next_unit(ptr, args, arg_flag, stage);
  1030.             if (isdigit(*result1) && isdigit(*result2))
  1031.             {
  1032.                 value1 = atol(result1);
  1033.                 value2 = atol(result2);
  1034.                 value1 = (value1 == value2) ? 0 : ((value1 <
  1035.                     value2) ? -1 : 1);
  1036.             }
  1037.             else
  1038.                 value1 = my_stricmp(result1, result2);
  1039.             if (value1)
  1040.             {
  1041.                 value2 = (value1 > 0) ? 1 : 0;
  1042.                 if (op == '<')
  1043.                     value2 = 1 - value2;
  1044.             }
  1045.             else
  1046.                 value2 = value3;
  1047.             new_free(&result2);
  1048.             sprintf(tmp, "%ld", value2);
  1049.             malloc_strcpy(&result1, tmp);
  1050.             return result1;
  1051.         case '~':
  1052.             if (ptr == str)
  1053.             {
  1054.                 if (stage != NU_BITW)
  1055.                     break;
  1056.                 result1 = next_unit(str+1, args, arg_flag,
  1057.                     stage);
  1058.                 if (isdigit(*result1))
  1059.                 {
  1060.                     value1 = atol(result1);
  1061.                     value2 = ~value1;
  1062.                 }
  1063.                 else
  1064.                     value2 = 0;
  1065.                 sprintf(tmp, "%ld", value2);
  1066.                 malloc_strcpy(&result1, tmp);
  1067.                 return result1;
  1068.             }
  1069.                         else
  1070.                         {
  1071.                                 ptr = lastop(ptr);
  1072.                                 break;
  1073.                         }
  1074.         case '!':
  1075.             if (ptr == str)
  1076.             {
  1077.                 if (stage != NU_UNIT)
  1078.                     break;
  1079.                 result1 = next_unit(str+1, args, arg_flag,
  1080.                     stage);
  1081.                 if (isdigit(*result1))
  1082.                 {
  1083.                     value1 = atol(result1);
  1084.                     value2 = value1 ? 0 : 1;
  1085.                 }
  1086.                 else
  1087.                 {
  1088.                     value2 = ((*result1)?0:1);
  1089.                 }
  1090.                 sprintf(tmp, "%ld", value2);
  1091.                 malloc_strcpy(&result1, tmp);
  1092.                 return result1;
  1093.             }
  1094.             if (stage != NU_COMP || ptr[1] != '=')
  1095.             {
  1096.                 ptr = lastop(ptr);
  1097.                 break;
  1098.             }
  1099.             *ptr = '\0';
  1100.             ptr += 2;
  1101.             result1 = next_unit(str, args, arg_flag, stage);
  1102.             result2 = next_unit(ptr, args, arg_flag, stage);
  1103.             if (!my_stricmp(result1, result2))
  1104.                 malloc_strcpy(&result1, "0");
  1105.             else
  1106.                 malloc_strcpy(&result1, "1");
  1107.             new_free(&result2);
  1108.             return result1;
  1109.                 case ',': 
  1110.             /*
  1111.              * this utterly kludge code is needed (?) to get
  1112.              * around bugs introduced from hop's patches to
  1113.              * alias.c.  the $, variable stopped working
  1114.              * because of this.  -mrg, july 94.
  1115.              */
  1116.             if (ptr == str || (ptr > str && ptr[-1] == '$'))
  1117.                 break;
  1118.                         if (stage != NU_EXPR)
  1119.                         {
  1120.                 ptr = lastop(ptr);
  1121.                 break;
  1122.             }
  1123.             *ptr++ = '\0';
  1124.             result1 = next_unit(str, args, arg_flag, stage);
  1125.             result2 = next_unit(ptr, args, arg_flag, stage);
  1126.             new_free(&result1);
  1127.             return result2;
  1128.         }
  1129.     }
  1130.     if (stage != NU_UNIT)
  1131.         return next_unit(str, args, arg_flag, stage+1);
  1132.     if (isdigit(*str) || *str == '+' || *str == '-')
  1133.         malloc_strcpy(&result1, str);
  1134.     else
  1135.     {
  1136.         if (*str == '#' || *str=='@')
  1137.             op = *str++;
  1138.         else
  1139.             op = '\0';
  1140.         result1 = find_inline(str);
  1141.         if (!result1)
  1142.             malloc_strcpy(&result1, empty_string);
  1143.         if (op)
  1144.         {
  1145.             if (op == '#')
  1146.                 value1 = word_count(result1);
  1147.             else if (op == '@')
  1148.                 value1 = strlen(result1);
  1149.             sprintf(tmp, "%ld", value1);
  1150.             malloc_strcpy(&result1, tmp);
  1151.         }
  1152.     }
  1153.     return result1;
  1154. }
  1155.  
  1156. /*
  1157.  * parse_inline:  This evaluates user-variable expression.  I'll talk more
  1158.  * about this at some future date. The ^ function and some fixes by
  1159.  * troy@cbme.unsw.EDU.AU (Troy Rollo) 
  1160.  */
  1161. char    *
  1162. parse_inline(str, args, args_flag)
  1163.     char    *str;
  1164.     char    *args;
  1165.     int    *args_flag;
  1166. {
  1167.     return next_unit(str, args, args_flag, NU_EXPR);
  1168. }
  1169.  
  1170. /*
  1171.  * arg_number: Returns the argument 'num' from 'str', or, if 'num' is
  1172.  * negative, returns from argument 'num' to the end of 'str'.  You might be
  1173.  * wondering what's going on down there... here goes.  First we copy 'str' to
  1174.  * malloced space.  Then, using next_arg(), we strip out each argument ,
  1175.  * putting them in arg_list, and putting their position in the original
  1176.  * string in arg_list_pos.  Anyway, once parsing is done, the arguments are
  1177.  * returned directly from the arg_list array... or in the case of negative
  1178.  * 'num', the arg_list_pos is used to return the postion of the rest of the
  1179.  * args in the original string... got it?  Anyway, the bad points of the
  1180.  * routine:  1) Always parses out everything, even if only one arg is used.
  1181.  * 2) The malloced stuff remains around until arg_number is called with a
  1182.  * different string. Even then, some malloced stuff remains around.  This can
  1183.  * be fixed. 
  1184.  */
  1185.  
  1186. #define    LAST_ARG 8000
  1187.  
  1188. extern    char    *arg_number(lower_lim, upper_lim, str)
  1189. int    lower_lim,
  1190.     upper_lim;
  1191. char    *str;
  1192. {
  1193.     char    *ptr,
  1194.         *arg,
  1195.         c;
  1196.     int    use_full = 0;
  1197.     unsigned int    pos,
  1198.         start_pos;
  1199.     static    char    *last_args = (char *) 0;
  1200.     static    char    *last_range = (char *) 0;
  1201.     static    char    **arg_list = (char **) 0;
  1202.     static    unsigned int    *arg_list_pos = (unsigned int *) 0;
  1203.     static    unsigned int    *arg_list_end_pos = (unsigned int *) 0;
  1204.     static    int    arg_list_size;
  1205.  
  1206.     if (eval_args)
  1207.     {
  1208.         int    arg_list_limit;
  1209.  
  1210.         eval_args = 0;
  1211.         new_free(&arg_list);
  1212.         new_free(&arg_list_pos);
  1213.         new_free(&arg_list_end_pos);
  1214.         arg_list_size = 0;
  1215.         arg_list_limit = 10;
  1216.         arg_list = (char **) new_malloc(sizeof(char *) *
  1217.             arg_list_limit);
  1218.         arg_list_pos = (unsigned int *) new_malloc(sizeof(unsigned int)
  1219.             * arg_list_limit);
  1220.         arg_list_end_pos = (unsigned int *) new_malloc(sizeof(unsigned
  1221.             int) * arg_list_limit);
  1222.         malloc_strcpy(&last_args, str);
  1223.         ptr = last_args;
  1224.         pos = 0;
  1225.         while ((arg = alias_arg(&ptr, &start_pos)) != NULL)
  1226.         {
  1227.             arg_list_pos[arg_list_size] = pos;
  1228.             pos += start_pos + strlen(arg);
  1229.             arg_list_end_pos[arg_list_size] = pos++;
  1230.             arg_list[arg_list_size++] = arg;
  1231.             if (arg_list_size == arg_list_limit)
  1232.             {
  1233.                 arg_list_limit += 10;
  1234.                 arg_list = (char **) new_realloc(arg_list,
  1235.                     sizeof(char *) * arg_list_limit);
  1236.                 arg_list_pos = (unsigned int *)
  1237.                     new_realloc(arg_list_pos,
  1238.                     sizeof(unsigned int) * arg_list_limit);
  1239.                 arg_list_end_pos = (unsigned int *)
  1240.                     new_realloc(arg_list_end_pos,
  1241.                     sizeof(unsigned int) *
  1242.                     arg_list_limit);
  1243.             }
  1244.         }
  1245.     }
  1246.     if (upper_lim == LAST_ARG && lower_lim == LAST_ARG)
  1247.         upper_lim = lower_lim = arg_list_size - 1;
  1248.     if (arg_list_size == 0)
  1249.         return (empty_string);
  1250.     if ((upper_lim >= arg_list_size) || (upper_lim < 0))
  1251.     {
  1252.         use_full = 1;
  1253.         upper_lim = arg_list_size - 1;
  1254.     }
  1255.     if (upper_lim < lower_lim)
  1256.                 return empty_string;
  1257.     if (lower_lim >= arg_list_size)
  1258.         lower_lim = arg_list_size - 1;
  1259.     else if (lower_lim < 0)
  1260.         lower_lim = 0;
  1261.     if ((use_full == 0) && (lower_lim == upper_lim))
  1262.         return (arg_list[lower_lim]);
  1263.     c = *(str + arg_list_end_pos[upper_lim]);
  1264.     *(str + arg_list_end_pos[upper_lim]) = (char) 0;
  1265.     malloc_strcpy(&last_range, str + arg_list_pos[lower_lim]);
  1266.     *(str + arg_list_end_pos[upper_lim]) = c;
  1267.     return (last_range);
  1268. }
  1269.  
  1270. /*
  1271.  * parse_number: returns the next number found in a string and moves the
  1272.  * string pointer beyond that point    in the string.  Here's some examples: 
  1273.  *
  1274.  * "123harhar"  returns 123 and str as "harhar" 
  1275.  *
  1276.  * while: 
  1277.  *
  1278.  * "hoohar"     returns -1  and str as "hoohar" 
  1279.  */
  1280. extern    int    
  1281. parse_number(str)
  1282.     char    **str;
  1283. {
  1284.     int    ret;
  1285.     char    *ptr;
  1286.  
  1287.     ptr = *str;
  1288.     if (isdigit(*ptr))
  1289.     {
  1290.         ret = atoi(ptr);
  1291.         for (; isdigit(*ptr); ptr++);
  1292.         *str = ptr;
  1293.     }
  1294.     else
  1295.         ret = -1;
  1296.     return (ret);
  1297. }
  1298.  
  1299. void    
  1300. do_alias_string()
  1301. {
  1302.     malloc_strcpy(&alias_string, get_input());
  1303.     irc_io_loop = 0;
  1304. }
  1305.  
  1306. /*
  1307.  * expander_addition: This handles string width formatting for irc variables
  1308.  * when [] is specified.  
  1309.  */
  1310. static    void    
  1311. expander_addition(buff, add, length, quote_em)
  1312.     char    *buff,
  1313.         *add;
  1314.     int    length;
  1315.     char    *quote_em;
  1316. {
  1317.     char    format[40],
  1318.         *ptr;
  1319.  
  1320.     if (length)
  1321.     {
  1322.         sprintf(format, "%%%d.%ds", -length, (length < 0 ? -length :
  1323.             length));
  1324.         sprintf(buffer, format, add);
  1325.         add = buffer;
  1326.     }
  1327.     if (quote_em)
  1328.     {
  1329.         ptr = double_quote(add, quote_em);
  1330.         strmcat(buff, ptr, BIG_BUFFER_SIZE);
  1331.         new_free(&ptr);
  1332.     }
  1333.     else
  1334.                 if (buff)
  1335.                 strmcat(buff, add, BIG_BUFFER_SIZE);
  1336. }
  1337.  
  1338. /* MatchingBracket returns the next unescaped bracket of the given type */
  1339. char    *
  1340. MatchingBracket(string, left, right)
  1341.     char    *string;
  1342.     char    left,
  1343.         right;
  1344. {
  1345.     int    bracket_count = 1;
  1346.  
  1347.     while (*string && bracket_count)
  1348.     {
  1349.         if (*string == left)
  1350.             bracket_count++;
  1351.         else if (*string == right)
  1352.         {
  1353.             if (!--bracket_count)
  1354.                 return string;
  1355.         }
  1356.         else if (*string == '\\' && string[1])
  1357.             string++;
  1358.         string++;
  1359.     }
  1360.     return (char *) 0;
  1361. }
  1362.  
  1363.  
  1364. /*
  1365.  * alias_special_char: Here we determin what to do with the character after
  1366.  * the $ in a line of text. The special characters are described more fulling
  1367.  * in the help/ALIAS file.  But they are all handled here. Paremeters are the
  1368.  * name of the alias (if applicable) to prevent deadly recursion, a
  1369.  * destination buffer (of size BIG_BUFFER_SIZE) to which things are appended,
  1370.  * a ptr to the string (the first character of which is the special
  1371.  * character, the args to the alias, and a character indication what
  1372.  * characters in the string should be quoted with a backslash.  It returns a
  1373.  * pointer to the character right after the converted alias.
  1374.  
  1375.  The args_flag is set to 1 if any of the $n, $n-, $n-m, $-m, $*, or $() is used
  1376.  in the alias.  Otherwise it is left unchanged.
  1377.  */
  1378. /*ARGSUSED*/
  1379. static    char    *
  1380. alias_special_char(name, buffer, ptr, args, quote_em,args_flag)
  1381.     char    *name;
  1382.     char    *buffer;
  1383.     char    *ptr;
  1384.     char    *args;
  1385.     char    *quote_em;
  1386.     int    *args_flag;
  1387. {
  1388.     char    *tmp,
  1389.         c;
  1390.     int    upper,
  1391.     lower,
  1392.     length;
  1393.  
  1394.     length = 0;
  1395.     if ((c = *ptr) == LEFT_BRACKET)
  1396.     {
  1397.         ptr++;
  1398.         if ((tmp = (char *) index(ptr, RIGHT_BRACKET)) != NULL)
  1399.         {
  1400.             *(tmp++) = (char) 0;
  1401.             length = atoi(ptr);
  1402.             ptr = tmp;
  1403.             c = *ptr;
  1404.         }
  1405.         else
  1406.         {
  1407.             say("Missing %c", RIGHT_BRACKET);
  1408.             return (ptr);
  1409.         }
  1410.     }
  1411.     tmp = ptr+1;
  1412.     switch (c)
  1413.     {
  1414.     case LEFT_PAREN:
  1415.         {
  1416.             define_big_buffer(sub_buffer);
  1417.  
  1418.             if ((ptr = MatchingBracket(tmp, LEFT_PAREN,
  1419.                 RIGHT_PAREN)) || (ptr = (char *) index(tmp,
  1420.                 RIGHT_PAREN)))
  1421.                 *(ptr++) = (char) 0;
  1422.             tmp = expand_alias((char *) 0, tmp, args, args_flag,
  1423.                 NULL);
  1424.             *sub_buffer = (char) 0;
  1425.             alias_special_char((char *) 0, sub_buffer, tmp,
  1426.                 args, quote_em,args_flag);
  1427.             expander_addition(buffer, sub_buffer, length, quote_em);
  1428.             new_free(&tmp);
  1429.             *args_flag = 1;
  1430.             free_big_buffer(sub_buffer);
  1431.         }
  1432.         return (ptr);
  1433.     case '!':
  1434.         if ((ptr = (char *) index(tmp, '!')) != NULL)
  1435.             *(ptr++) = (char) 0;
  1436.         if ((tmp = do_history(tmp, empty_string)) != NULL)
  1437.         {
  1438.             expander_addition(buffer, tmp, length, quote_em);
  1439.             new_free(&tmp);
  1440.         }
  1441.         return (ptr);
  1442.     case LEFT_BRACE:
  1443.         if ((ptr = (char *) index(tmp, RIGHT_BRACE)) != NULL)
  1444.             *(ptr++) = (char) 0;
  1445.         if ((tmp = parse_inline(tmp, args, args_flag)) != NULL)
  1446.         {
  1447.             expander_addition(buffer, tmp, length, quote_em);
  1448.             new_free(&tmp);
  1449.         }
  1450.         return (ptr);
  1451.     case DOUBLE_QUOTE:
  1452.         if ((ptr = (char *) index(tmp, DOUBLE_QUOTE)) != NULL)
  1453.             *(ptr++) = (char) 0;
  1454.         alias_string = (char *) 0;
  1455.         if (irc_io(tmp, do_alias_string, use_input, 1))
  1456.         {
  1457.             yell("Illegal recursive edit");
  1458.             break;
  1459.         }
  1460.         expander_addition(buffer, alias_string, length, quote_em);
  1461.         new_free(&alias_string);
  1462.         return (ptr);
  1463.     case '*':
  1464.         expander_addition(buffer, args, length, quote_em);
  1465.         *args_flag = 1;
  1466.         return (ptr + 1);
  1467.     default:
  1468.         if (isdigit(c) || (c == '-') || c == '~')
  1469.         {
  1470.             *args_flag = 1;
  1471.             if (*ptr == '~')
  1472.             {
  1473.                 lower = upper = LAST_ARG;
  1474.                 ptr++;
  1475.             }
  1476.             else
  1477.             {
  1478.                 lower = parse_number(&ptr);
  1479.                 if (*ptr == '-')
  1480.                 {
  1481.                     ptr++;
  1482.                     upper = parse_number(&ptr);
  1483.                 }
  1484.                 else
  1485.                     upper = lower;
  1486.             }
  1487.             expander_addition(buffer, arg_number(lower, upper,
  1488.                 args), length, quote_em);
  1489.             return (ptr ? ptr : empty_string);
  1490.         }
  1491.         else
  1492.         {
  1493.             char    *rest,
  1494.                 c = (char) 0;
  1495.  
  1496.         /*
  1497.          * Why use ptr+1?  Cause try to maintain backward compatability
  1498.          * can be a pain in the butt.  Basically, we don't want any of
  1499.          * the illegal characters in the alias, except that things like
  1500.          * $* and $, were around first, so they must remain legal.  So
  1501.          * we skip the first char after the $.  Does this make sense?
  1502.          */
  1503.             /* special case for $ */
  1504.             if (*ptr == '$')
  1505.             {
  1506.                 rest = ptr+1;
  1507.                 c = *rest;
  1508.                 *rest = (char) 0;
  1509.             }
  1510.             else if ((rest = sindex(ptr+1, alias_illegals)) != NULL)
  1511.             {
  1512.                 if (isalpha(*ptr) || *ptr == '_')
  1513.                     while ((*rest == LEFT_BRACKET ||
  1514.                         *rest == LEFT_PAREN) &&
  1515.                         (tmp = MatchingBracket(rest+1,
  1516.                         *rest, (*rest == LEFT_BRACKET) ?
  1517.                         RIGHT_BRACKET: RIGHT_PAREN)))
  1518.                         rest = tmp + 1;
  1519.                 c = *rest;
  1520.                 *rest = (char) 0;
  1521.             }
  1522.             if ((tmp = parse_inline(ptr, args, args_flag)) != NULL)
  1523.             {
  1524.                 expander_addition(buffer, tmp, length,
  1525.                     quote_em);
  1526.                 new_free(&tmp);
  1527.             }
  1528.             if (rest)
  1529.                 *rest = c;
  1530.             return(rest);
  1531.         }
  1532.     }
  1533.     return NULL;
  1534. }
  1535.  
  1536.  
  1537. /*
  1538.  * expand_alias: Expands inline variables in the given string and returns the
  1539.  * expanded string in a new string which is malloced by expand_alias(). 
  1540.  *
  1541.  * Also unescapes anything that was quoted with a backslash
  1542.  *
  1543.  * Behaviour is modified by the following:
  1544.  *    Anything between brackets (...) {...} is left unmodified.
  1545.  *    If more_text is supplied, the text is broken up at
  1546.  *        semi-colons and returned one at a time. The unprocessed
  1547.  *        portion is written back into more_text.
  1548.  *    Backslash escapes are unescaped.
  1549.  */
  1550.  
  1551. char    *
  1552. expand_alias(name, string, args,args_flag, more_text)
  1553.     char    *name,
  1554.         *string,
  1555.         *args;
  1556.     int    *args_flag;
  1557.     char    **more_text;
  1558. {
  1559.     define_big_buffer(buffer);
  1560.     char    *ptr,
  1561.         *stuff = (char *) 0,
  1562.         *free_stuff;
  1563.     char    *quote_em,
  1564.         *quote_str = (char *) 0;
  1565.     char    ch;
  1566.     int    quote_cnt = 0;
  1567.     int    is_quote = 0;
  1568.     void    (*str_cat)();
  1569.  
  1570.     if (*string == '@' && more_text)
  1571.     {
  1572.         str_cat = strmcat;
  1573.         *args_flag = 1; /* Stop the @ command from auto appending */
  1574.     }
  1575.     else
  1576.         str_cat = strmcat_ue;
  1577.     malloc_strcpy(&stuff, string);
  1578.     free_stuff = stuff;
  1579.     *buffer = (char) 0;
  1580.     eval_args = 1;
  1581.     ptr = stuff;
  1582.     if (more_text)
  1583.         *more_text = NULL;
  1584.     while (ptr && *ptr)
  1585.     {
  1586.         if (is_quote)
  1587.         {
  1588.             is_quote = 0;
  1589.             ++ptr;
  1590.             continue;
  1591.         }
  1592.         switch(*ptr)
  1593.         {
  1594.         case '$':
  1595.     /*
  1596.      * The test here ensures that if we are in the expression
  1597.      * evaluation command, we don't expand $. In this case we
  1598.      * are only coming here to do command separation at ';'s.
  1599.      * If more_text is not defined, and the first character is
  1600.      * '@', we have come here from [] in an expression.
  1601.      */
  1602.             if (more_text && *string == '@')
  1603.             {
  1604.                 ptr++;
  1605.                 break;
  1606.             }
  1607.             *(ptr++) = (char) 0;
  1608.             (*str_cat)(buffer, stuff, BIG_BUFFER_SIZE);
  1609.             while (*ptr == '^')
  1610.             {
  1611.                 ptr++;
  1612.                 if (quote_str)
  1613.                     quote_str = (char *)
  1614.                         new_realloc(quote_str,
  1615.                         sizeof(char) * (quote_cnt + 2));
  1616.                 else
  1617.                     quote_str = (char *)
  1618.                         new_malloc(sizeof(char) *
  1619.                         (quote_cnt + 2));
  1620.                 quote_str[quote_cnt++] = *(ptr++);
  1621.                 quote_str[quote_cnt] = (char) 0;
  1622.             }
  1623.             quote_em = quote_str;
  1624.             stuff = alias_special_char(name, buffer, ptr, args,
  1625.                 quote_em, args_flag);
  1626.             if (stuff)
  1627.                 new_free("e_str);
  1628.             quote_cnt = 0;
  1629.             ptr = stuff;
  1630.             break;
  1631.         case ';':
  1632.             if (!more_text)
  1633.             {
  1634.                 ptr++;
  1635.                 break;
  1636.             }
  1637.             *more_text = string + (ptr - free_stuff) +1;
  1638.             *ptr = '\0'; /* To terminate the loop */
  1639.             break;
  1640.         case LEFT_PAREN:
  1641.         case LEFT_BRACE:
  1642.             ch = *ptr;
  1643.             *ptr = '\0';
  1644.             (*str_cat)(buffer, stuff, BIG_BUFFER_SIZE);
  1645.             stuff = ptr;
  1646.             *args_flag = 1;
  1647.             if (!(ptr = MatchingBracket(stuff + 1, ch,
  1648.                     (ch == LEFT_PAREN) ?
  1649.                     RIGHT_PAREN : RIGHT_BRACE)))
  1650.             {
  1651.                 yell("Unmatched %c", ch);
  1652.                 ptr = stuff + strlen(stuff+1)+1;
  1653.             }
  1654.             else
  1655.                 ptr++;
  1656.             *stuff = ch;
  1657.             ch = *ptr;
  1658.             *ptr = '\0';
  1659.             strmcat(buffer, stuff, BIG_BUFFER_SIZE);
  1660.             stuff = ptr;
  1661.             *ptr = ch;
  1662.             break;
  1663.         case '\\':
  1664.             is_quote = 1;
  1665.             ptr++;
  1666.             break;
  1667.         default:
  1668.             ptr++;
  1669.             break;
  1670.         }
  1671.     }
  1672.     if (stuff)
  1673.         (*str_cat)(buffer, stuff, BIG_BUFFER_SIZE);
  1674.     ptr = (char *) 0;
  1675.     new_free(&free_stuff);
  1676.     malloc_strcpy(&ptr, buffer);
  1677.     if (get_int_var(DEBUG_VAR) & DEBUG_EXPANSIONS)
  1678.         yell("Expanded [%s] to [%s]",
  1679.             string, ptr);
  1680.     free_big_buffer(buffer);
  1681.     return (ptr);
  1682. }
  1683.  
  1684. /*
  1685.  * get_alias: returns the alias matching 'name' as the function value. 'args'
  1686.  * are expanded as needed, etc.  If no matching alias is found, null is
  1687.  * returned, cnt is 0, and full_name is null.  If one matching alias is
  1688.  * found, it is retuned, with cnt set to 1 and full_name set to the full name
  1689.  * of the alias.  If more than 1 match are found, null is returned, cnt is
  1690.  * set to the number of matches, and fullname is null. NOTE: get_alias()
  1691.  * mallocs the space for the full_name, but returns the actual value of the
  1692.  * alias if found! 
  1693.  */
  1694. char    *
  1695. get_alias(type, name, cnt, full_name)
  1696.     int    type;
  1697.     char    *name,
  1698.         **full_name;
  1699.     int    *cnt;
  1700. {
  1701.     Alias    *tmp;
  1702.  
  1703.     *full_name = (char *) 0;
  1704.     if ((name == (char *) 0) || (*name == (char) 0))
  1705.     {
  1706.         *cnt = 0;
  1707.         return ((char *) 0);
  1708.     }
  1709.     if ((tmp = find_alias(&(alias_list[type]), name, 0, cnt)) != NULL)
  1710.     {
  1711.         if (*cnt < 2)
  1712.         {
  1713.             malloc_strcpy(full_name, tmp->name);
  1714.             return (tmp->stuff);
  1715.         }
  1716.     }
  1717.     return ((char *) 0);
  1718. }
  1719.  
  1720. /*
  1721.  * match_alias: this returns a list of alias names that match the given name.
  1722.  * This is used for command completion etc.  Note that the returned array is
  1723.  * malloced in this routine.  Returns null if no matches are found 
  1724.  */
  1725. char    **
  1726. match_alias(name, cnt, type)
  1727.     char    *name;
  1728.     int    *cnt;
  1729.     int    type;
  1730. {
  1731.     Alias    *tmp;
  1732.     char    **matches = (char **) 0;
  1733.     int    matches_size = 5;
  1734.     int    len;
  1735.     char    *last_match = (char *) 0;
  1736.     char    *dot;
  1737.  
  1738.     len = strlen(name);
  1739.     *cnt = 0;
  1740.     matches = (char    **) new_malloc(sizeof(char *) * matches_size);
  1741.     for (tmp = alias_list[type]; tmp; tmp = tmp->next)
  1742.     {
  1743.         if (strncmp(name, tmp->name, len) == 0)
  1744.         {
  1745.             if ((dot = (char *) index(tmp->name+len, '.')) != NULL)
  1746.             {
  1747.                 if (type == COMMAND_ALIAS)
  1748.                     continue;
  1749.                 else
  1750.                 {
  1751.                     *dot = '\0';
  1752.                     if (last_match && !strcmp(last_match,
  1753.                             tmp->name))
  1754.                     {
  1755.                         *dot = '.';
  1756.                         continue;
  1757.                     }
  1758.                 }
  1759.             }
  1760.             matches[*cnt] = (char *) 0;
  1761.             malloc_strcpy(&(matches[*cnt]), tmp->name);
  1762.             last_match = matches[*cnt];
  1763.             if (dot)
  1764.                 *dot = '.';
  1765.             if (++(*cnt) == matches_size)
  1766.             {
  1767.                 matches_size += 5;
  1768.                 matches = (char    **) new_realloc(matches,
  1769.                     sizeof(char *) * matches_size);
  1770.             }
  1771.         }
  1772.         else if (*cnt)
  1773.             break;
  1774.     }
  1775.     if (*cnt)
  1776.     {
  1777.         matches = (char    **) new_realloc(matches, sizeof(char *) *
  1778.             (*cnt + 1));
  1779.         matches[*cnt] = (char *) 0;
  1780.     }
  1781.     else
  1782.         new_free(&matches);
  1783.     return (matches);
  1784. }
  1785.  
  1786. /* delete_alias: The alias name is removed from the alias list. */
  1787. void
  1788. delete_alias(type, name)
  1789.     int    type;
  1790.     char    *name;
  1791. {
  1792.     Alias    *tmp;
  1793.  
  1794.     upper(name);
  1795.     if ((tmp = find_alias(&(alias_list[type]), name, 1, (int *) NULL))
  1796.             != NULL)
  1797.     {
  1798.         new_free(&(tmp->name));
  1799.         new_free(&(tmp->stuff));
  1800.         new_free(&tmp);
  1801.         if (type == COMMAND_ALIAS)
  1802.             say("Alias    %s removed", name);
  1803.         else
  1804.             say("Assign %s removed", name);
  1805.     }
  1806.     else
  1807.         say("No such alias: %s", name);
  1808. }
  1809.  
  1810. /*
  1811.  * list_aliases: Lists all aliases matching 'name'.  If name is null, all
  1812.  * aliases are listed 
  1813.  */
  1814. void
  1815. list_aliases(type, name)
  1816.     int    type;
  1817.     char    *name;
  1818. {
  1819.     Alias    *tmp;
  1820.     int    len;
  1821.     int    DotLoc,
  1822.         LastDotLoc = 0;
  1823.     char    *LastStructName = NULL;
  1824.     char    *s;
  1825.  
  1826.     if (type == COMMAND_ALIAS)
  1827.         say("Aliases:");
  1828.     else
  1829.         say("Assigns:");
  1830.     if (name)
  1831.     {
  1832.         upper(name);
  1833.         len = strlen(name);
  1834.     }
  1835.     else
  1836.         len = 0;
  1837.     for (tmp = alias_list[type]; tmp; tmp = tmp->next)
  1838.  
  1839.     {
  1840.         if (!name || !strncmp(tmp->name, name, len))
  1841.         {
  1842.             s = index(tmp->name + len, '.');
  1843.             if (!s)
  1844.                 say("\t%s\t%s", tmp->name, tmp->stuff);
  1845.             else
  1846.             {
  1847.                 DotLoc = s - tmp->name;
  1848.                 if (!LastStructName || (DotLoc != LastDotLoc) || strncmp(tmp->name, LastStructName, DotLoc))
  1849.                 {
  1850.                     say("\t%*.*s\t<Structure>", DotLoc, DotLoc, tmp->name);
  1851.                     LastStructName = tmp->name;
  1852.                     LastDotLoc = DotLoc;
  1853.                 }
  1854.             }
  1855.         }
  1856.     }
  1857. }
  1858.  
  1859. /*
  1860.  * mark_alias: sets the mark field of the given alias to 'flag', and returns
  1861.  * the previous value of the mark.  If the name is not found, -1 is returned.
  1862.  * This is used to prevent recursive aliases by marking and unmarking
  1863.  * aliases, and not reusing an alias that has previously been marked.  I'll
  1864.  * explain later 
  1865.  */
  1866. int
  1867. mark_alias(name, flag)
  1868.     char    *name;
  1869.     int    flag;
  1870. {
  1871.     int    old_mark;
  1872.     Alias    *tmp;
  1873.     int    match;
  1874.  
  1875.     if ((tmp = find_alias(&(alias_list[COMMAND_ALIAS]), name, 0, &match))
  1876.             != NULL)
  1877.     {
  1878.         if (match < 2)
  1879.         {
  1880.             old_mark = tmp->mark;
  1881.         /* New handling of recursion */
  1882.             if (flag)
  1883.             {
  1884.                 int    i;
  1885.                 /* Count recursion */
  1886.  
  1887.                 tmp->mark = tmp->mark + flag;
  1888.                 if ((i = get_int_var(MAX_RECURSIONS_VAR)) > 1)
  1889.                 {
  1890.                     if (tmp->mark > i)
  1891.                     {
  1892.                         tmp->mark = 0;
  1893.                         return(1); /* MAX exceeded. */
  1894.                     }
  1895.                     else return(0);
  1896.                 /* In recursion but it's ok */
  1897.                 }
  1898.                 else
  1899.                 {
  1900.                     if (tmp->mark > 1)
  1901.                     {
  1902.                         tmp->mark = 0;
  1903.                         return(1);
  1904.                 /* max of 1 here.. exceeded */
  1905.                     }
  1906.                     else return(0);
  1907.                 /* In recursion but it's ok */
  1908.                 }
  1909.             }
  1910.             else
  1911.         /* Not in recursion at all */
  1912.             {
  1913.                 tmp->mark = 0;
  1914.                 return(old_mark);
  1915.             /* This one gets ignored anyway */
  1916.             }
  1917.         }
  1918.     }
  1919.     return (-1);
  1920. }
  1921.  
  1922. /*
  1923.  * execute_alias: After an alias has been identified and expanded, it is sent
  1924.  * here for proper execution.  This routine mainly prevents recursive
  1925.  * aliasing.  The name is the full name of the alias, and the alias is
  1926.  * already expanded alias (both of these parameters are returned by
  1927.  * get_alias()) 
  1928.  */
  1929. void
  1930. execute_alias(alias_name, alias, args)
  1931.     char    *alias_name,
  1932.         *alias,
  1933.         *args;
  1934. {
  1935.     if (mark_alias(alias_name, 1))
  1936.         say("Maximum recursion count exceeded in: %s", alias_name);
  1937.     else
  1938.     {
  1939.         parse_line(alias_name, alias, args, 0,1);
  1940.         mark_alias(alias_name, 0);
  1941.     }
  1942. }
  1943.  
  1944. /*
  1945.  * save_aliases: This will write all of the aliases to the FILE pointer fp in
  1946.  * such a way that they can be read back in using LOAD or the -l switch 
  1947.  */
  1948. void
  1949. save_aliases(fp, do_all)
  1950.     FILE    *fp;
  1951.     int    do_all;
  1952. {
  1953.     Alias    *tmp;
  1954.  
  1955.     for (tmp = alias_list[VAR_ALIAS]; tmp; tmp = tmp->next)
  1956.         if (!tmp->global || do_all)
  1957.             fprintf(fp, "ASSIGN %s %s\n", tmp->name, tmp->stuff);
  1958.     for (tmp = alias_list[COMMAND_ALIAS]; tmp; tmp = tmp->next)
  1959.         if (!tmp->global || do_all)
  1960.             fprintf(fp, "ALIAS %s %s\n", tmp->name, tmp->stuff);
  1961. }
  1962.  
  1963. /* The Built-In Alias expando functions */
  1964. static    char    *
  1965. alias_line()
  1966. {
  1967.     return(get_input());
  1968. }
  1969.  
  1970. static    char    *
  1971. alias_buffer()
  1972. {
  1973.     return cut_buffer;
  1974. }
  1975.  
  1976. static    char    *
  1977. alias_time()
  1978. {
  1979.     return(update_clock(GET_TIME));
  1980. }
  1981.  
  1982. static    char    *
  1983. alias_dollar()
  1984. {
  1985.     return("$");
  1986. }
  1987.  
  1988. static    char    *
  1989. alias_detected()
  1990. {
  1991.     return last_notify_nick;
  1992. }
  1993.  
  1994. static    char    *
  1995. alias_nick()
  1996. {
  1997.     return(get_server_nickname(curr_scr_win->server));
  1998. }
  1999.  
  2000. static    char    *
  2001. alias_away()
  2002. {
  2003.     return server_list[curr_scr_win->server].away;
  2004. }
  2005.  
  2006. static    char    *
  2007. alias_sent_nick()
  2008. {
  2009.     return (sent_nick) ? sent_nick : empty_string;
  2010. }
  2011.  
  2012. static    char    *
  2013. alias_recv_nick()
  2014. {
  2015.     return (recv_nick) ? recv_nick : empty_string;
  2016. }
  2017.  
  2018. static    char    *
  2019. alias_msg_body()
  2020. {
  2021.     return (sent_body) ? sent_body : empty_string;
  2022. }
  2023.  
  2024. static    char    *
  2025. alias_joined_nick()
  2026. {
  2027.     return (joined_nick) ? joined_nick : empty_string;
  2028. }
  2029.  
  2030. static    char    *
  2031. alias_public_nick()
  2032. {
  2033.     return (public_nick) ? public_nick : empty_string;
  2034. }
  2035.  
  2036. static    char    *
  2037. alias_channel()
  2038. {
  2039.     char    *tmp;
  2040.  
  2041.     return (tmp = get_channel_by_refnum(0)) ? tmp : "0";
  2042. }
  2043.  
  2044. static    char    *
  2045. alias_server()
  2046. {
  2047.     return (parsing_server_index == -1) ?
  2048.         get_server_itsname(parsing_server_index) :
  2049.         (get_window_server(0) != -1) ?
  2050.             get_server_itsname(get_window_server(0)) : empty_string;
  2051. }
  2052.  
  2053. static    char    *
  2054. alias_query_nick()
  2055. {
  2056.     char    *tmp;
  2057.  
  2058.     return (tmp = query_nick()) ? tmp : empty_string;
  2059. }
  2060.  
  2061. static    char    *
  2062. alias_target()
  2063. {
  2064.     char    *tmp;
  2065.  
  2066.     return (tmp = get_target_by_refnum(0)) ? tmp : empty_string;
  2067. }
  2068.  
  2069. static    char    *
  2070. alias_invite()
  2071. {
  2072.     return (invite_channel) ? invite_channel : empty_string;
  2073. }
  2074.  
  2075. static    char    *
  2076. alias_cmdchar()
  2077. {
  2078.     static    char    thing[2];
  2079.     char    *cmdchars;
  2080.  
  2081.     if ((cmdchars = get_string_var(CMDCHARS_VAR)) == (char *) 0)
  2082.         cmdchars = DEFAULT_CMDCHARS;
  2083.     thing[0] = cmdchars[0];
  2084.     thing[1] = (char) 0;
  2085.     return(thing);
  2086. }
  2087.  
  2088. static    char    *
  2089. alias_oper()
  2090. {
  2091.     return get_server_operator(from_server) ?
  2092.         get_string_var(STATUS_OPER_VAR) : empty_string;
  2093. }
  2094.  
  2095. static    char    *
  2096. alias_chanop()
  2097. {
  2098.     char    *tmp;
  2099.  
  2100.     return ((tmp = get_channel_by_refnum(0)) && get_channel_oper(tmp,
  2101.             from_server)) ?
  2102.         "@" : empty_string;
  2103. }
  2104.  
  2105. static    char    *
  2106. alias_modes()
  2107. {
  2108.     char    *tmp;
  2109.  
  2110.     return (tmp = get_channel_by_refnum(0)) ?
  2111.         get_channel_mode(tmp, from_server) : empty_string;
  2112. }
  2113.  
  2114. /*
  2115.  * alias: the /ALIAS command.  Calls the correct alias function depending on
  2116.  * the args 
  2117.  */
  2118. void    
  2119. alias(command, args)
  2120.     char    *command,
  2121.         *args;
  2122. {
  2123.     char    *name,
  2124.         *rest;
  2125.     int    type;
  2126.     char    *ArrayIndex;
  2127.     char    *EndIndex;
  2128.  
  2129.     type = *command - 48;    /*
  2130.                  * A trick!  Yes, well, what the hell.  Note
  2131.                                  * the the command part of ALIAS is "0" and
  2132.                                  * the command part of ASSIGN is "1" in the
  2133.                  * command array list
  2134.                  */
  2135.     if ((name = next_arg(args, &rest)) != NULL)
  2136.     {
  2137.         while ((ArrayIndex = (char *) index(name, '[')) != NULL)
  2138.         {
  2139.             *ArrayIndex++ = '.';
  2140.             if ((EndIndex = MatchingBracket(ArrayIndex,
  2141.                     LEFT_BRACKET, RIGHT_BRACKET)) != NULL)
  2142.             {
  2143.                 *EndIndex++ = '\0';
  2144.                 strcat(name, EndIndex);
  2145.             }
  2146.             else
  2147.                 break;
  2148.         }
  2149.         if (*rest)
  2150.         {
  2151.             if (*rest == LEFT_BRACE)
  2152.             {
  2153.                 char    *ptr = MatchingBracket(++rest,
  2154.                         LEFT_BRACE, RIGHT_BRACE);
  2155.                 if (!ptr)
  2156.                     say("Unmatched brace in ALIAS or ASSIGN");
  2157.                 else if (ptr[1])
  2158.                 {
  2159.                     say("Junk after closing brace in ALIAS or ASSIGN");
  2160.                 }
  2161.                 else
  2162.                 {
  2163.                     *ptr = '\0';
  2164.                     add_alias(type, name, rest);
  2165.                 }
  2166.             }
  2167.             else
  2168.                 add_alias(type, name, rest);
  2169.         }
  2170.         else
  2171.         {
  2172.             if (*name == '-')
  2173.             {
  2174.                 if (*(name + 1))
  2175.                     delete_alias(type, name + 1);
  2176.                 else
  2177.                     say("You must specify an alias to be removed");
  2178.             }
  2179.             else
  2180.                 list_aliases(type, name);
  2181.         }
  2182.     }
  2183.     else
  2184.         list_aliases(type, (char *) 0);
  2185. }
  2186.  
  2187.  
  2188.  
  2189. char    *
  2190. function_left(input)
  2191.     char    *input;
  2192. {
  2193.     char    *result = (char *) 0;
  2194.     char    *count;
  2195.     int    cvalue;
  2196.  
  2197.     count = next_arg(input, &input);
  2198.     if (count)
  2199.         cvalue = atoi(count);
  2200.     else
  2201.         cvalue = 0;
  2202.     if (strlen(input) > cvalue)
  2203.         input[cvalue] = '\0';
  2204.     malloc_strcpy(&result, input);
  2205.     return result;
  2206. }
  2207.  
  2208. char    *
  2209. function_right(input)
  2210.     char    *input;
  2211. {
  2212.     char    *result = (char *) 0;
  2213.     char    *count;
  2214.     int    cvalue;
  2215.  
  2216.     count = next_arg(input, &input);
  2217.     if (count)
  2218.         cvalue = atoi(count);
  2219.     else
  2220.         cvalue = 0;
  2221.     if (strlen(input) > cvalue)
  2222.         input += strlen(input) - cvalue;
  2223.     malloc_strcpy(&result, input);
  2224.     return result;
  2225. }
  2226.  
  2227. char    *
  2228. function_mid(input)
  2229.     char    *input;
  2230. {
  2231.     char    *result = (char *) 0;
  2232.     char    *index;
  2233.     int    ivalue;
  2234.     char    *count;
  2235.     int    cvalue;
  2236.  
  2237.     index = next_arg(input, &input);
  2238.     if (index)
  2239.         ivalue = atoi(index);
  2240.     else
  2241.         ivalue = 0;
  2242.     count = next_arg(input, &input);
  2243.     if (count)
  2244.         cvalue = atoi(count);
  2245.     else
  2246.         cvalue = 0;
  2247.     if (strlen(input) > ivalue)
  2248.         input += ivalue;
  2249.     else
  2250.         *input = (char) 0;
  2251.     if (strlen(input) > cvalue)
  2252.         input[cvalue] = (char) 0;
  2253.     malloc_strcpy(&result, input);
  2254.     return result;
  2255. }
  2256.  
  2257. /* patch from Sarayan to make $rand() better */
  2258.  
  2259. #define RAND_A 16807L
  2260. #define RAND_M 2147483647L
  2261. #define RAND_Q 127773L
  2262. #define RAND_R 2836L
  2263.  
  2264. static    long    
  2265. randm(l)
  2266.     long    l;
  2267. {
  2268.     static    u_long    z = 0;
  2269.     long    t;
  2270.  
  2271. #ifndef __MSDOS__
  2272.     if (!z)
  2273.         z = (u_long) getuid();
  2274. #endif
  2275.     if (!l)
  2276.     {
  2277.         t = RAND_A * (z % RAND_Q) - RAND_R * (z / RAND_Q);
  2278.         if (t > 0)
  2279.             z = t;
  2280.         else
  2281.             z = t + RAND_M;
  2282.         return (z >> 8) | ((z & 255) << 23);
  2283.     }
  2284.     else
  2285.     {
  2286.         if (l < 0)
  2287. #ifdef __MSDOS__
  2288.             z = 0;
  2289. #else
  2290.             z = (u_long) getuid();
  2291. #endif
  2292.         else
  2293.             z = l;
  2294.         return 0;
  2295.     }
  2296. }
  2297.  
  2298. char    *
  2299. function_rand(input)
  2300.     char    *input;
  2301. {
  2302.     char    *result = (char *) 0;
  2303.     char    tmp[40];
  2304.     long    tempin;
  2305.  
  2306.     sprintf(tmp, "%ld", (tempin = atol(input)) ? randm(0L) % tempin : 0);
  2307.     malloc_strcpy(&result, tmp);
  2308.     return result;
  2309. }
  2310.  
  2311. char    *
  2312. function_srand(input)
  2313.     char    *input;
  2314. {
  2315.     char    *result = (char *) 0;
  2316.  
  2317.     if (input && *input)
  2318.         (void) randm(atol(input));
  2319.     else
  2320.         (void) randm((time_t) time(NULL));
  2321.     malloc_strcpy(&result, empty_string);
  2322.     return result;
  2323. }
  2324.  
  2325. /*ARGSUSED*/
  2326. char    *
  2327. function_time(input)
  2328.     char    *input;
  2329. {
  2330.     char    *result = (char *) 0;
  2331.     time_t    ltime;
  2332.     char    tmp[40];
  2333.  
  2334.     (void) time(<ime);
  2335.     sprintf(tmp, "%ld", ltime);
  2336.     malloc_strcpy(&result, tmp);
  2337.     return result;
  2338. }
  2339.  
  2340. char    *
  2341. function_stime(input)
  2342.     char    *input;
  2343. {
  2344.     char    *result = (char *) 0;
  2345.     time_t    ltime;
  2346.  
  2347.     ltime = atol(input);
  2348.     malloc_strcpy(&result, ctime(<ime));
  2349.     result[strlen(result) - 1] = (char) 0;
  2350.     return result;
  2351. }
  2352.  
  2353. char    *
  2354. function_tdiff(input)
  2355.     char    *input;
  2356. {
  2357.     char    *result = (char *) 0;
  2358.     time_t    ltime;
  2359.     time_t    days,
  2360.         hours,
  2361.         minutes,
  2362.         seconds;
  2363.     char    tmp[80];
  2364.     char    *tstr;
  2365.  
  2366.     ltime = atol(input);
  2367.     seconds = ltime % 60;
  2368.     ltime = (ltime - seconds) / 60;
  2369.     minutes = ltime%60;
  2370.     ltime = (ltime - minutes) / 60;
  2371.     hours = ltime % 24;
  2372.     days = (ltime - hours) / 24;
  2373.     tstr = tmp;
  2374.     if (days)
  2375.     {
  2376.         sprintf(tstr, "%d day%s ", days, (days==1)?"":"s");
  2377.         tstr += strlen(tstr);
  2378.     }
  2379.     if (hours)
  2380.     {
  2381.         sprintf(tstr, "%d hour%s ", hours, (hours==1)?"":"s");
  2382.         tstr += strlen(tstr);
  2383.     }
  2384.     if (minutes)
  2385.     {
  2386.         sprintf(tstr, "%d minute%s ", minutes, (minutes==1)?"":"s");
  2387.         tstr += strlen(tstr);
  2388.     }
  2389.     if (seconds || (!days && !hours && !minutes))
  2390.     {
  2391.         sprintf(tstr, "%d second%s", seconds, (seconds==1)?"":"s");
  2392.         tstr += strlen(tstr);
  2393.     }
  2394.     malloc_strcpy(&result, tmp);
  2395.     return result;
  2396. }
  2397.  
  2398. char    *
  2399. function_index(input)
  2400.     char    *input;
  2401. {
  2402.     char    *result = (char *) 0;
  2403.     char    *schars;
  2404.     char    *iloc;
  2405.     int    ival;
  2406.     char    tmp[40];
  2407.  
  2408.     schars = next_arg(input, &input);
  2409.     iloc = (schars) ? sindex(input, schars) : NULL;
  2410.     ival = (iloc) ? iloc - input : -1;
  2411.     sprintf(tmp, "%d", ival);
  2412.     malloc_strcpy(&result, tmp);
  2413.     return result;
  2414. }
  2415.  
  2416. char    *
  2417. function_rindex(input)
  2418.     char    *input;
  2419. {
  2420.     char    *result = (char *) 0;
  2421.     char    *schars;
  2422.     char    *iloc, *liloc;
  2423.     int    ival;
  2424.     char    tmp[40];
  2425.  
  2426.     schars = next_arg(input, &input);
  2427.     iloc = NULL;
  2428.     if (schars)
  2429.     {
  2430.         liloc = sindex(input, schars);
  2431.         while (liloc)
  2432.             liloc = sindex((iloc = liloc) + 1, schars);
  2433.     }
  2434.     ival = (iloc) ? iloc-input : -1;
  2435.     sprintf(tmp, "%d", ival);
  2436.     malloc_strcpy(&result, tmp);
  2437.     return result;
  2438. }
  2439.  
  2440. char    *
  2441. function_match(input)
  2442.     char    *input;
  2443. {
  2444.     char    *result = (char *) 0;
  2445.     char    *pattern;
  2446.     char    *word;
  2447.     int    current_match;
  2448.     int    best_match = 0;
  2449.     int    match = 0;
  2450.     int    index = 0;
  2451.     char    tmp[40];
  2452.  
  2453.     if ((pattern = next_arg(input, &input)) != NULL)
  2454.     {
  2455.         while ((word = next_arg(input, &input)) != NULL)
  2456.         {
  2457.             index++;
  2458.             if ((current_match = wild_match(pattern, word))
  2459.                     > best_match)
  2460.             {
  2461.                 match = index;
  2462.                 best_match=current_match;
  2463.             }
  2464.         }
  2465.     }
  2466.     sprintf(tmp, "%d", match);
  2467.     malloc_strcpy(&result, tmp);
  2468.     return result;
  2469. }
  2470.  
  2471. char    *
  2472. function_rmatch(input)
  2473.     char    *input;
  2474. {
  2475.     char    *result = (char *) 0;
  2476.     char    *pattern;
  2477.     char    *word;
  2478.     int    current_match;
  2479.     int    best_match = 0;
  2480.     int    match = 0;
  2481.     int    index = 0;
  2482.     char    tmp[40];
  2483.  
  2484.     if ((pattern = next_arg(input, &input)) != NULL)
  2485.     {
  2486.         while ((word = next_arg(input, &input)) != NULL)
  2487.         {
  2488.             index++;
  2489.             if ((current_match = wild_match(word, pattern)) >
  2490.                     best_match)
  2491.             {
  2492.                 match = index;
  2493.                 best_match = current_match;
  2494.             }
  2495.         }
  2496.     }
  2497.     sprintf(tmp, "%d", match);
  2498.     malloc_strcpy(&result, tmp);
  2499.     return result;
  2500. }
  2501.  
  2502. /*ARGSUSED*/
  2503. char    *
  2504. function_userhost(input)
  2505.     char    *input;
  2506. {
  2507.     char    *result = (char *) 0;
  2508.  
  2509.     malloc_strcpy(&result, FromUserHost ? FromUserHost : empty_string);
  2510.     return result;
  2511. }
  2512.  
  2513. char    *
  2514. function_strip(input)
  2515.     char    *input;
  2516. {
  2517.     static    char    FAR result[BIG_BUFFER_SIZE+1] = "";
  2518.     char    *retval = (char *) 0;
  2519.     char    *chars;
  2520.     char    *cp, *dp;
  2521.  
  2522.     if ((chars = next_arg(input, &input)) && input)
  2523.     {
  2524.         for (cp = input, dp = result; *cp; cp++)
  2525.         {
  2526.             if (!index(chars, *cp))
  2527.                 *dp++ = *cp;
  2528.         }
  2529.         *dp = '\0';
  2530.     }
  2531.     malloc_strcpy(&retval, result);
  2532.     return retval;
  2533. }
  2534.  
  2535. char    *
  2536. function_encode(input)
  2537.     unsigned char    *input;
  2538. {
  2539.     static unsigned char    FAR result[BIG_BUFFER_SIZE+1] = "";
  2540.     char    *retval = (char *) 0;
  2541.     unsigned char    *c;
  2542.     int    i = 0;
  2543.  
  2544.     for (c = input; *c; c++)
  2545.     {
  2546.         result[i++] = (*c >> 4) + 0x41;
  2547.         result[i++] = (*c & 0x0f) + 0x41;
  2548.     }
  2549.     result[i] = '\0';
  2550.     malloc_strcpy(&retval, result);
  2551.     return retval;
  2552. }
  2553.  
  2554.  
  2555. char    *
  2556. function_decode(input)
  2557.     unsigned char    *input;
  2558. {
  2559.     static unsigned    char    FAR result[BIG_BUFFER_SIZE+1] = "";
  2560.     char    *retval = (char *) 0;
  2561.     unsigned char    *c;
  2562.     unsigned char    d,e;
  2563.     int    i = 0;
  2564.  
  2565.     c = input;
  2566.     while((d = *c) && (e = *(c+1)))
  2567.     {
  2568.         result[i] = ((d - 0x41) << 4) | (e - 0x41);
  2569.         c += 2;
  2570.         i++;
  2571.     }
  2572.     result[i] = '\0';
  2573.     malloc_strcpy(&retval, result);
  2574.     return retval;
  2575. }
  2576.  
  2577. char    *
  2578. function_ischannel(input)
  2579.     char    *input;
  2580. {
  2581.     char    *result = (char *) 0;
  2582.  
  2583.     malloc_strcpy(&result, is_channel(input) ? "1" : "0");
  2584.     return result;
  2585. }
  2586.  
  2587. char    *
  2588. function_ischanop(input)
  2589.     char    *input;
  2590. {
  2591.     char    *result = (char *) 0;
  2592.     char    *nick;
  2593.     char    *channel = NULL;
  2594.  
  2595.     if (!(nick = next_arg(input, &channel)))
  2596.         malloc_strcpy(&result, "0");
  2597.     else
  2598.         malloc_strcpy(&result, is_chanop(channel, nick) ? "1" : "0");
  2599.     return result;
  2600. }
  2601.  
  2602.  
  2603. char    *
  2604. function_word(input)
  2605.     char    *input;
  2606. {
  2607.     char    *result = (char *) 0;
  2608.     char    *count;
  2609.     int    cvalue;
  2610.     char    *word;
  2611.  
  2612.     count = next_arg(input, &input);
  2613.     if (count)
  2614.         cvalue = atoi(count);
  2615.     else
  2616.         cvalue = 0;
  2617.     if (cvalue < 0)
  2618.         malloc_strcpy(&result, empty_string);
  2619.     else
  2620.     {
  2621.         for (word = next_arg(input, &input); word && cvalue--;
  2622.                 word = next_arg(input, &input))
  2623.             ;
  2624.         malloc_strcpy(&result, (word) ? word : empty_string);
  2625.     }
  2626.     return result;
  2627. }
  2628.  
  2629.  
  2630. char    *
  2631. function_winnum(input)
  2632.     char    *input;
  2633. {
  2634.     char    *result = (char *) 0;
  2635.     char    tmp[10];
  2636.  
  2637.     if (curr_scr_win)
  2638.         sprintf(tmp, "%d", curr_scr_win->refnum);
  2639.     else
  2640.         strcpy(tmp, "-1");
  2641.     malloc_strcpy(&result, tmp);
  2642.     return result;
  2643. }
  2644.  
  2645. char    *
  2646. function_winnam(input)
  2647.     char    *input;
  2648. {
  2649.     char    *result = (char *) 0;
  2650.  
  2651.     malloc_strcpy(&result, (curr_scr_win && curr_scr_win->name) ?
  2652.         curr_scr_win->name : empty_string);
  2653.     return result;
  2654. }
  2655.  
  2656. char    *
  2657. function_connect(input)
  2658.     char    *input;
  2659. {
  2660.     char    *result = (char *) 0;
  2661.     char    *host;
  2662.  
  2663. #ifdef DAEMON_UID
  2664.     if (getuid() == DAEMON_UID)
  2665.         put_it("You are not permitted to use CONNECT()");
  2666.     else
  2667. #endif
  2668.         if ((host = next_arg(input, &input)) != NULL)
  2669.             result = dcc_raw_connect(host, atoi(input));
  2670.     return result;
  2671. }
  2672.  
  2673.  
  2674. char    *
  2675. function_listen(input)
  2676.     char    *input;
  2677. {
  2678.     char    *result = (char *) 0;
  2679.  
  2680. #ifdef DAEMON_UID
  2681.     if (getuid() == DAEMON_UID)
  2682.         malloc_strcpy(&result, "0");
  2683.     else
  2684. #endif
  2685.         result = dcc_raw_listen(atoi(input));
  2686.     return result;
  2687. }
  2688.  
  2689. static    char    *
  2690. alias_version(input)
  2691.     char    *input;
  2692. {
  2693.     char *result = (char *) 0;
  2694.     malloc_strcpy(&result, internal_version);
  2695.     return result;
  2696. }
  2697.  
  2698. static    char    *
  2699. alias_currdir(input)
  2700.     char    *input;
  2701. {
  2702.     char    *result = (char *) 0;
  2703.  
  2704.         getcwd(buffer, BIG_BUFFER_SIZE+1);
  2705.     /* is this more portable? *shrug*. i chose BIG_BUFFER_SIZE+1
  2706.        because it's more readable -cgw- */
  2707.     /* getcwd((char *)buffer, sizeof((char *)buffer)); */
  2708.     malloc_strcpy(&result, buffer);
  2709.     return result;
  2710. }
  2711.  
  2712. static    char    *
  2713. alias_current_numeric(input)
  2714.     char    *input;
  2715. {
  2716.     char    *result = (char *) 0,
  2717.         number[4];
  2718.     
  2719.     sprintf(number, "%03d", -current_numeric);
  2720.     malloc_strcpy(&result, number);
  2721.     return result;
  2722. }
  2723.  
  2724. static    char    *
  2725. alias_server_version(input)
  2726.     char    *input;
  2727. {
  2728.     char    *result = (char *) 0,
  2729.         *s;
  2730.  
  2731.     malloc_strcpy(&result,
  2732.         (s = server_list[curr_scr_win->server].version_string) ?
  2733.                 s : empty_string);
  2734.     return result;
  2735. }
  2736.  
  2737. char    *
  2738. function_toupper(input)
  2739.     char    *input;
  2740. {
  2741.     char    *new = (char *) 0,
  2742.         *ptr;
  2743.  
  2744.     if (!input)
  2745.         return empty_string;
  2746.     malloc_strcpy(&new, input);
  2747.     for (ptr = new; *ptr; ptr++)
  2748.         *ptr = islower(*ptr) ? toupper(*ptr) : *ptr;
  2749.     return new;
  2750. }
  2751.  
  2752. char    *
  2753. function_tolower(input)
  2754.     char    *input;
  2755. {
  2756.     char    *new = (char *) 0,
  2757.         *ptr;
  2758.  
  2759.     if (!input)
  2760.         return empty_string;
  2761.     malloc_strcpy(&new, input);
  2762.     for (ptr = new; *ptr; ptr++)
  2763.         *ptr = (isupper(*ptr)) ? tolower(*ptr) : *ptr;
  2764.     return new;
  2765. }
  2766.  
  2767. char    *
  2768. function_curpos(input)
  2769.     char    *input;
  2770. {
  2771.     char    *new = (char *) 0,
  2772.         pos[4];
  2773.  
  2774.     sprintf(pos, "%d", current_screen->buffer_pos);
  2775.     malloc_strcpy(&new, pos);
  2776.     return new;
  2777. }
  2778.  
  2779. char    *
  2780. function_channels(input)
  2781.     char    *input;
  2782. {
  2783.     Window    *window;
  2784.  
  2785.     if (input)
  2786.         window = isdigit(*input) ? get_window_by_refnum(atoi(input))
  2787.                      : curr_scr_win;
  2788.     else
  2789.         window = curr_scr_win;
  2790.  
  2791.     return create_channel_list(window);
  2792. }
  2793.  
  2794. char    *
  2795. function_servers(input)
  2796.     char    *input;
  2797. {
  2798.     return create_server_list();
  2799. }
  2800.  
  2801. char    *
  2802. function_onchannel(input)
  2803.     char    *input;
  2804. {
  2805.     char    *result = (char *) 0;
  2806.     char    *nick;
  2807.     char    *channel = NULL;
  2808.  
  2809.     if (!(nick = next_arg(input, &channel)))
  2810.         malloc_strcpy(&result, "0");
  2811.     else
  2812.         malloc_strcpy(&result, is_on_channel(channel, nick) ? "1"
  2813.                                     : "0");
  2814.     return result;
  2815. }
  2816.  
  2817. char    *
  2818. function_pid(input)
  2819.     char    *input;
  2820. {
  2821.     char    *result = (char *) 0;
  2822.  
  2823.     sprintf(buffer, "%d", (int) getpid());
  2824.     malloc_strcpy(&result, buffer);
  2825.     return result;
  2826. }
  2827.  
  2828. char    *
  2829. function_ppid(input)
  2830.     char    *input;
  2831. {
  2832.     char    *result = (char *) 0;
  2833.  
  2834.     sprintf(buffer, "%d", (int) getppid());
  2835.     malloc_strcpy(&result, buffer);
  2836.     return result;
  2837. }
  2838.  
  2839. char    *
  2840. function_chanusers(input)
  2841.     char    *input;
  2842. {
  2843.     ChannelList    *chan;
  2844.     NickList    *nicks;
  2845.     char    *result = (char *) 0;
  2846.  
  2847.     chan = lookup_channel(from_server, input, 0);
  2848.     if ((ChannelList *) 0 == chan)
  2849.         return (char *) 0;
  2850.  
  2851.     for (nicks = chan->nicks; nicks; nicks = nicks->next)
  2852.     {
  2853.         strcat(buffer, " ");
  2854.         strcat(buffer, nicks->nick);
  2855.     }
  2856.     malloc_strcpy(&result, buffer + 1);
  2857.     return result;
  2858. }
  2859.  
  2860.  
  2861. /*
  2862.  * strftime() patch from hari (markc@arbld.unimelb.edu.au)
  2863.  */
  2864. char    *
  2865. function_strftime(input)
  2866.     char     *input;
  2867. {
  2868.     char    result[128];
  2869.     time_t    ltime;
  2870.     char    *fmt = (char *) 0;
  2871.  
  2872.     ltime = atol(input);
  2873.     fmt = input;
  2874.     /* skip the time field */
  2875.     while (isdigit(*fmt))
  2876.         ++fmt; 
  2877.     if (*fmt && *++fmt)
  2878.     {
  2879.         struct tm    *tm;
  2880.  
  2881.         tm = localtime(<ime);
  2882.         if (strftime(result, 128, fmt, tm))
  2883.         {
  2884.             char *    s = (char *) 0;
  2885.  
  2886.             malloc_strcpy(&s, result);
  2887.             return s;
  2888.         }
  2889.         else
  2890.             return (char *) 0;
  2891.     }
  2892.     else
  2893.     {
  2894.         return (char *) 0;
  2895.     }
  2896. }
  2897.